importClass('java.io.FileOutputStream');
importClass('java.io.IOException');
importClass('java.io.InputStream');
importClass('java.net.MalformedURLException');
importClass('java.net.URL');
importClass('java.net.URLConnection');
importClass('java.util.ArrayList');


/**
 * 最基础的网址
 */
const SERVER_BASE_ADDR = "http://server.wzdy.fkapp.top:38886"
const SERVER_BASE_ADDR_WS = "ws://server.wzdy.fkapp.top:38886/wwws/ws/"
// const SERVER_BASE_ADDR_WS = "ws://server.wzdy.fkapp.top:13001"
//  const SERVER_BASE_ADDR_WS = "ws://180.76.225.84/wwws/ws/"


Date.prototype.Format = function(fmt)   
{
    var o = {   
        "M+" : this.getMonth()+1,                 //月份   
        "d+" : this.getDate(),                    //日   
        "h+" : this.getHours(),                   //小时   
        "m+" : this.getMinutes(),                 //分   
        "s+" : this.getSeconds(),                 //秒   
        "q+" : Math.floor((this.getMonth()+3)/3), //季度   
        "S"  : this.getMilliseconds()             //毫秒   
    };   
    if(/(y+)/.test(fmt))   
        fmt=fmt.replace(RegExp.$1, (this.getFullYear()+"").substr(4 - RegExp.$1.length));   
    for(var k in o)   
        if(new RegExp("("+ k +")").test(fmt))   
            fmt = fmt.replace(RegExp.$1, (RegExp.$1.length==1) ? (o[k]) : (("00"+ o[k]).substr((""+ o[k]).length)));
    return fmt;
}

let EnumBaseInfo = {
    VERSION: "100",                      // 版本号
    APPNAME: "小萌兔",                      // App的名字
    APP_VERSION: {          // App的版本号
        Major: 1,           // 主版本号
        Minor: 1,           // 子版本号
        Revision: 1,        // 修正版本号
    },
    SCRIPT_VERSION: {       // 脚本的版本号
        Major: 0,
        Minor: 0,
        Revision: 3,
    },
    STATE: "准备开始",                      // 状态
    DEBUB: false,                          // 调试状态
    FW_Dy_ScrollVideoInfo: null,                          // 悬浮窗，用于显示刷了多少个视频和刷了多少时间
    FW_Dy_ScrollLiveRoomInfo: null,                          // 悬浮窗，用于显示刷了多少个直播间
    FW_DebugInfo: null,              // 悬浮窗，显示调试信息
    FW_Button: null,              // 悬浮窗，操作按钮
    FW_DugInfo_Eng: null,           // 悬浮窗，显示调试信息的脚本
}

/**
 * 系统配置信息
 */
var EnumSysConf = {
    username: '',           // 用户名
    pw_card: '',            // 卡号
    pw_key: '',             // 密钥
    version_latest_script: "0",     // 版本号

    imei: device.getIMEI(), // IEMI
    win_h: device.height,   // 窗口的高度
    win_w: device.width,    // 窗口的宽度

    t_in_tj_max: 0,         // 随机看推荐页作品的时间
    t_in_tj_min: 0,
    t_in_gz_max: 0,         // 随机看关注页的时间
    t_in_gz_min: 0,
    t_in_zb_max: 0,         // 随机直播间停留的时间
    t_in_zb_min: 0,
    int_in_grzy_max: 0,     // 随机刷个人主页的数量
    int_in_grzy_min: 0,
    super_man_name: '',     // 特别关注人的名字
    super_man_name_into_room: '',     // 从特别关注页面进入直播间的名字
    t_in_care_room_max: 0,  // 在特别关注直播间停留的时间，
    t_in_care_room_min: 0,
    t_out_care_room_max: 0, // 退出特别关注直播间刷其他视频的时间，如果这个时候刷到了特别关注的直播间就进入
    t_out_care_room_min: 0,


    b_isCareRoomClose: false,   // true，关注的直播间结束后进入养号模式


    b_isLookTime: false,    // 是否看时间
    d_LookTime: 10,         // 看的分钟
    b_isLookNo: false,      // 是否看数量
    d_LookNo: 10,           // 看数量
    b_isRunEveryDay: false, // true 每天都运行
    d_RunHour: 0,           // 每天哪个小时开始运行
    super_room_id: '',      // 要进入的直播间ID
    b_is_super_man: false,  // true 需要对特别关注的人操作

    b_isScrollLiveRoom: false,  // true 刷直播间
    d_ScrollLiveRoom_LookTime: 10,  // 刷直播间的时间
}

/**
 * 获取系统的配置信息
 */
function GetSysConf() {
    LoadAllVariable();
    return EnumSysConf;
}

/**
 * 加载需要的全部变量
 */
function LoadAllVariable() {
    var storage = storages.create("rabbit:info");

    EnumSysConf.username = storage.get('username', "vip001");
    EnumSysConf.pw_card = storage.get('pw_card', '');
    EnumSysConf.pw_key = storage.get('pw_key', '');
    EnumSysConf.version_latest_script = storage.get('version_latest_script', '0');
    EnumSysConf.t_in_tj_min = storage.get('t_in_tj_min', 5*1000*60);
    EnumSysConf.t_in_tj_max = storage.get('t_in_tj_max', 20*1000*60);
    EnumSysConf.t_in_gz_min = storage.get('t_in_gz_min', 5*1000*60);
    EnumSysConf.t_in_gz_max = storage.get('t_in_gz_max', 20*1000*60);
    EnumSysConf.t_in_zb_min = storage.get('t_in_zb_min', 3*1000*60);
    EnumSysConf.t_in_zb_max = storage.get('t_in_zb_max', 30*1000*60);
    
    EnumSysConf.int_in_grzy_min = storage.get('int_in_grzy_min', 2);
    EnumSysConf.int_in_grzy_max = storage.get('int_in_grzy_max', 6);

    EnumSysConf.super_man_name = storage.get('super_man_name', '');
    EnumSysConf.super_man_name_into_room = storage.get('super_man_name_into_room', '');
    EnumSysConf.t_in_care_room_min = storage.get('t_in_care_room_min', 13*1000*60);
    EnumSysConf.t_in_care_room_max = storage.get('t_in_care_room_max', 15*1000*60);
    
    EnumSysConf.t_out_care_room_min = storage.get('t_out_care_room_min', 3*1000*60);
    EnumSysConf.t_out_care_room_max = storage.get('t_out_care_room_max', 5*1000*60);


    if (storage.get('b_isCareRoomClose', 0) == 1) {
        EnumSysConf.b_isCareRoomClose = true;
    } else {
        EnumSysConf.b_isCareRoomClose = false;     
    }
    


    if (storage.get('is_look_time', 0) == 1) {
        EnumSysConf.b_isLookTime = true;
    } else {
        EnumSysConf.b_isLookTime = false;     
    }
    EnumSysConf.d_LookTime = storage.get('look_time', '');
    if (storage.get('is_look_no', 0) == 1) {
        EnumSysConf.b_isLookNo = true;
    } else {
        EnumSysConf.b_isLookNo = false;      
    }
    EnumSysConf.d_LookNo = storage.get('look_no', '');

    if (storage.get('is_run_EveryDay', 0) == 1) {
        EnumSysConf.b_isRunEveryDay = true;
    } else {
        EnumSysConf.b_isRunEveryDay = false;      
    }
    EnumSysConf.d_RunHour = storage.get('RunHour', '');
    EnumSysConf.super_room_id = storage.get('super_room_id', '');
    if (storage.get('is_super_man', 0) == 1) {
        EnumSysConf.b_is_super_man = true;
    }else{
        EnumSysConf.b_is_super_man = false;
    }    
    

    if (storage.get('is_liveRoom_time', 0) == 1) {
        EnumSysConf.b_isScrollLiveRoom = true;
    }else{
        EnumSysConf.b_isScrollLiveRoom = false;
    }    
    EnumSysConf.d_ScrollLiveRoom_LookTime = storage.get('ScrollLiveRoom_LookTime', '');
}

/**
 * 更新Ui界面
 */
function UpDataUi() {
    LoadAllVariable();
    ui.run(()=>{
        // let storage = storages.create("rabbit:info");
        // EnumSysConf.username = storage.get("username", "vip001");
        // EnumSysConf.pw_card = storage.get("pw_card", "");

        ui.username.setText(EnumSysConf.username);
        ui.password_card.setText(EnumSysConf.pw_card);
        ui.script_version.setText(EnumSysConf.version_latest_script);
        let ShowVariable = "参数情况：\n" + 
        "**********    养号脚本    **********\n" +
        "  推荐页时长：" + EnumSysConf.t_in_tj_min/1000/60 + " ~ " + EnumSysConf.t_in_tj_max/1000/60 + " 分钟\n" + 
        "  关注页时长：" + EnumSysConf.t_in_gz_min/1000/60 + " ~ " + EnumSysConf.t_in_zb_max/1000/60 + " 分钟\n" + 
        "  直播间停留时长：" + EnumSysConf.t_in_zb_min/1000/60 + " ~ " + EnumSysConf.t_in_zb_max/1000/60 + " 分钟\n" + 
        "  个人主页浏览数量：" + EnumSysConf.int_in_grzy_min + " ~ " + EnumSysConf.int_in_grzy_max + "  个\n" + 
        "  特别关注：" + EnumSysConf.super_man_name + "\n" + 
        "\n**********  刷直播间脚本  **********\n" + 
        "  直播间作者名：" + EnumSysConf.super_man_name_into_room + "\n" + 
        "  直播间停留 " + EnumSysConf.t_in_care_room_min/1000/60 + " ~ " + EnumSysConf.t_in_care_room_max/1000/60 + " 分钟后重新进入\n" + 
        "" + 
        "**********      End      **********\n"
        ui.script_info.setText(ShowVariable);
        // ui.script_info.setText("第一行\n第二行\n第三行\n第四行");
    })
}

/**
 * 设置当前脚本的状态
 * @param {*} state 设置的状态
 */
function SetState(state) {
    EnumBaseInfo.STATE = state;
    console.log(new Date().Format('hh:mm:ss -> ') + state);
}

/**
 * 获取当前脚本的状态
 * @returns 返回当前的脚本状态
 */
function GetState() {
    return EnumBaseInfo.STATE;
}

/**
 * 自己的滑动函数
 */
function swipe_s(x1, y1, x2, y2, t){
    swipe(x1, y1, x2, y2, t);
    // if (EnumSlfConf.isNeedRoot) {
    //     // EnumSlfConf.ra.swipe(x1, y1, x2, y2, t);
    //     libEx.RSwipeEx(x1, y1, x2, y2, t);
    // }else{
    //     swipe(x1, y1, x2, y2, t);
    // }
}

/**
 * 点亮屏幕
 */
 function ScreenLight() {
    // console.log(new Date().Format('hh:mm:ss -> ') + '点亮屏幕');
    // if (!device.isScreenOn() || libEx.isDeviceLocked()) {
    //     console.log(new Date().Format('hh:mm:ss -> ') +'需要解锁屏幕');
    //     OpenScreen();
    //     sleep(1 * 1000);
    // }
    while (device.isScreenOn() == false) {
        device.wakeUpIfNeeded();
        sleep(100 * 3);
    }
    sleep(1 * 1000);
    device.setBrightness(80)
}

/**
 * 让屏幕亮度最低
 */
function ScreenDim() {
    console.log(new Date().Format('hh:mm:ss -> ') + '让屏幕亮度最低');
    device.setBrightness(0)
    // ScreenClose();
}

/**
 * 一键锁屏
 */
 function ScreenClose() {
    console.log(new Date().Format('hh:mm:ss -> ') + '关闭手机屏幕');
    importClass(android.content.Context);
    importClass(android.app.admin.DevicePolicyManager);
    // (DevicePolicyManager)
    policyManager = context.getSystemService(Context.DEVICE_POLICY_SERVICE);
    policyManager.lockNow();
}

/**
 * 是否锁屏
 * @returns  锁屏返回true
 */
function isDeviceLocked(){
    importClass(android.app.KeyguardManager)
    importClass(android.content.Context)

    var km = context.getSystemService(Context.KEYGUARD_SERVICE);
    // console.log(new Date().Format('hh:mm:ss -> ') + "is keyguard locked:"+km.isKeyguardLocked());
    // console.log(new Date().Format('hh:mm:ss -> ') + "is keyguard secure:"+km.isKeyguardSecure());
    return km.isKeyguardLocked() || km.isKeyguardSecure();
}

/**
 * 屏幕解锁
 */
function OpenScreen(){
    console.log(new Date().Format('hh:mm:ss -> ') + "点亮屏幕");
    device.wakeUp();
    // device.keepScreenDim(20 * 1000);
    device.keepScreenDim();
    sleep(1000 * 2);
    var win_w = device.width;
    var win_h = device.height;

    // a = win_w/ 4 * 3 + 5
    // c = win_w/ 4 * 3 - 2    
    a = win_w - 10
    c = win_w - 10 
    b = win_h/ 10 * 9
    // b = win_h - 10;
    d = win_h/ 10 * 3

    swipe(a,b,c,d, 210);
    sleep(1000);
}

/**
 * 通过最近任务关闭软件，清理后台运行的程序
 * 
 * com.huawei.android.launcher:id/clear_all_recents_image_button
 * packageName:com.huawei.android.launcher
 * desc:关闭所有最近打开的应用
 * TODO：可以再进行优化
 */
function CloseAppByRecents() {

    // 显示出来最近的任务
    console.log("打开最近任务");
    recents();

    sleep(1000 * 3);

    // 查找关闭所有最近打开的应用按钮
    var btn_clear_all_recents = selector().desc("关闭所有最近打开的应用");
    if (btn_clear_all_recents.exists()) {
        console.log("点击：关闭所有最近打开的应用");
        btn_clear_all_recents.findOne().click();
    }else{
        console.log("没有找到：关闭所有最近打开的应用");
    }
}


/**
 * 通过ID特征查找是否在这这个软件内部
 * @param {*} featureId ：软件的ID特征前缀
 */
function isInSomeAppById(featureId) {
    if (selector().idStartsWith(featureId).exists()) {
        return true;
    }else{
        return false;
    }
}

/**
 * 在伏羲X软件中打开应用
 * @param {*} AppNameInFx ：App在伏羲软件内的名字
 * @param {*} featureId ：软件的ID特征前缀
 */
function OpenAppInFX(AppNameInFx, featureId) {
    const fxApp = "io.virtualapp.sandvxposed64"
    // const fxApp = "io.virtualapp.sandvxposed"
    
    console.log("打开伏羲X");
    CloseAppByRecents();
    sleep(1000 * 5);
    app.launchPackage(fxApp);
    /**
     * 1、等待伏羲X的打开
     * 2、找到想要打开的软件
     * 3、点击想要找开的软件
     * 4、等待不在伏羲X中
     */
    var i_count = 0
    while (!selector().packageName(fxApp).exists()) {
        if (i_count > 20) {
            console.log("没有打开伏羲软件，重新打开。");
            OpenAppInFX(AppNameInFx, featureId);
        }
        sleep(1000);
        i_count = i_count + 1;
    }

    i_count = 0
    while (!selector().textStartsWith(AppNameInFx).exists()) {
        if (i_count > 20) {
            console.log("没有找到需要打开伏羲软件，重新打开。");
            OpenAppInFX(AppNameInFx, featureId);
        }
        sleep(1000);
        i_count = i_count + 1;
    }

    sleep(1000);

    if (selector().textStartsWith(AppNameInFx).findOne(5000).parent().click()) {
        console.log("点击成功");
    }else {
        console.log("点击失败");
        console.log("没有打开 指定软件，重新打开。");
        OpenAppInFX(AppNameInFx, featureId);
    }

    i_count = 0
    while (!isInSomeAppById(featureId)) {
        if (i_count > 30) {
            console.log("点击后打开指定软件出现错误，重新打开。");
            OpenAppInFX(AppNameInFx, featureId);
        }
        sleep(1000);
        i_count = i_count + 1; 
    }
}

/**
 * 节点点击的进化版本，如果本节点不能点击则点击父节点。
 * @param {*} node ：传入需要点击的节点
 */
function ClickNodeEx(node){
    for (let index = 0; index < 5; index++) {
        if (node && !node.click()) {
            console.log(new Date().Format('hh:mm:ss -> ') + 'count:' + index);
            node = node.parent();
        }else{
            break;
        }    
    }
}

/**
 * 将服务器上的脚本下载到本地。
 * @param {string} url 下载地址
 * @param {string} filePath 本地保存地址
 */
function DownloadFile(url, filePath) {
    var url = new URL(url);
    var conn = url.openConnection(); //URLConnection
    var inStream = conn.getInputStream(); //InputStream
    var fs = new FileOutputStream(filePath); //FileOutputStream
    var connLength = conn.getContentLength(); //int
    var buffer = util.java.array('byte', 1024); //byte[]
    var byteSum = 0; //总共读取的文件大小
    var byteRead; //每次读取的byte数
    log('要下载的文件大小=', connLength);
    var threadId = threads.start(function() {
        let nowDate = new Date();
        while (new Date() - nowDate < 1000 * 10) {
            var 当前写入的文件大小 = byteSum;
            var progress = (当前写入的文件大小 / connLength) * 100;
            if (progress > 0.1) {
                var progress = parseInt(progress).toString() + '%';
                if (当前写入的文件大小 >= connLength) {
                    break;
                }
            }
            sleep(1000);
        }
    });
    while ((byteRead = inStream.read(buffer)) != -1) {
        byteSum += byteRead;
        //当前时间
        currentTime = java.lang.System.currentTimeMillis();
        fs.write(buffer, 0, byteRead); //读取
    }
    threadId && threadId.isAlive() && threadId.interrupt();
    console.log('下载完成');
}

/**
 * Setting界面的相关操作
 */

/**
 * 打开通知栏窗口
 */
 function openNtfActivity() {
    app.openPkgActivity("com.android.settings", 'com.android.settings.Settings$NotificationAppListActivity');
}

/**
 * 关闭应用的通知权限
 * TODO： 这个还没有做
 */
function closeNtfOrder() {
    openNtfActivity();
    sleep(1000 * 5);

    var btn_TZHZTL = selector().textStartsWith(/(.*通知智能管理.*)/).findOne(1000 * 10);

    if (btn_TZHZTL) {
        ClickEx(btn_TZHZTL);
    }else{
        console.log(new Date().Format('hh:mm:ss -> ') + "没有找到通知和状态栏");
        alert("没有找到通知和状态栏");
        return;
    }
    sleep(1000 * 5);
  
    var btn_jihuo = selector().textMatches(/(.*激活设备管理员.*)/).findOne(1000 * 10);

    if (btn_jihuo) {
        ClickEx(btn_jihuo);
    }else{
        console.log(new Date().Format('hh:mm:ss -> ') + "没有找到激活管理员");
        // alert("没有找到激活管理员");
        return;
    }
    sleep(1000 * 5);

}

/**
 * 打开设备管理界面
 */
function openDeviceAdmin() {
    app.openSettingDeviceAdmin();
}

/**
 * 打开指定的设备管理器并激活
 * 通过设备管理器的名字激活指定的设备管理器
 * @param {*} DeviceName 想要打开的设备管理器的名字
 */
function activateAppDeviceAdmin(DeviceName) {
    setState('打开指定的设备管理器并激活');
    openDeviceAdmin();
    sleep(1000 * 5);

    var btn_device_name = selector().textStartsWith(DeviceName).findOne(1000 * 10);

    if (btn_device_name) {
        ClickEx(btn_device_name);
    }else{
        console.log(new Date().Format('hh:mm:ss -> ') + "没有找到指定的设备管理器名");
        // alert("没有找到指定的设备管理器名");
        back();
        return;
    }
    sleep(1000 * 3);
  
    var btn_jihuo = selector().text('激活此设备管理员').findOne(1000 * 10);

    if (btn_jihuo) {
        ClickEx(btn_jihuo);
    }else{
        console.log(new Date().Format('hh:mm:ss -> ') + "没有找到激活管理员");
        // alert("没有找到激活管理员");
        return;
    }
    back();
    sleep(1000);
    back();
    sleep(1000 * 3);
}

/**
 * 打开安全界面并设置无锁屏
 */
function openSecurity() {
    app.openPkgActivity("com.android.settings", 'com.android.settings.Settings$SecuritySettingsActivity');
}

/**
 * 设置无锁屏
 */
function setNoLockScreen() {
    setState('设置无锁屏');
    openSecurity();
    sleep(1000 * 2);

    var btn_unlock_method = selector().textMatches(/(.*解锁方式.*|.*解锁.*)/).findOne(1000 * 10);

    if (btn_unlock_method) {
        ClickEx(btn_unlock_method);
    }else{
        console.log(new Date().Format('hh:mm:ss -> ') + "没有出现解锁方法");
        alert("没有出现解锁方法");
        return;
    }
    sleep(1000 * 1);
  
    var btn_unlock_no_method = selector().textMatches(/(.*无锁屏.*)/).findOne(1000 * 10);

    if (btn_unlock_no_method) {
        ClickEx(btn_unlock_no_method);
    }else{
        console.log(new Date().Format('hh:mm:ss -> ') + "没有出现无锁屏");
        alert("没有出现无锁屏");
        return;
    }
    sleep(1000 * 2);
}

/**
 * 卸载指定包名的App
 * @param {string} appName App 的包名
 */
function uninstallApp(appName) {
    setState('卸载指定包名的App');

    var name = getPackageName(appName); 
    if(!name){
        if(getAppName(appName)){
            name = appName;
        }else{
            console.log(new Date().Format('hh:mm:ss -> ') + '没有找到应用');
            return false;
        } 
    }

    app.uninstall(name);
    // 弹出确认按钮然后点击确定
    sleep(1000 * 3);
    selector().textMatches(/(.*确.*|.*定.*|.*卸.*|.*载.*)/).clickable(true).findOne(1000 * 5).click();
    sleep(1000 * 5);
}

module.exports = {
    SERVER_BASE_ADDR: SERVER_BASE_ADDR,         // 最基础的网址
    EnumSysConf: EnumSysConf,                   // 基础的信息
    SERVER_BASE_ADDR_WS: SERVER_BASE_ADDR_WS,   // 最基础的ws地址
    
    GetSysConf: GetSysConf,                     // 获取系统的配置信息 

    LoadAllVariable: LoadAllVariable,           // 加载需要的全部变量

    UpDataUi: UpDataUi,                         // 更新Ui界面

    swipe_s : swipe_s,                          // 自己的滑动函数
    CloseAppByRecents : CloseAppByRecents,      // 通过最近任务关闭软件
    OpenAppInFX: OpenAppInFX,                   // 在伏羲X软件中打开应用

    ClickNodeEx : ClickNodeEx,                  // 

    isInSomeAppById: isInSomeAppById,

    SetState: SetState,                         //
    GetState: GetState,                         //

    DownloadFile: DownloadFile,                 // 将服务器上的脚本下载到本地


    // 系统相关
    isDeviceLocked: isDeviceLocked,                     // 是否锁屏

    // 屏幕相关操作
    ScreenLight: ScreenLight,                           // 点亮屏幕
    ScreenDim: ScreenDim,                               // 让屏幕亮度最低
    ScreenClose: ScreenClose,                           // 关闭手机屏幕
    OpenScreen: OpenScreen,                             // 屏幕解锁

    // 设置界面相关操作
    uninstallApp: uninstallApp,                         // 卸载指定包名的App
    setNoLockScreen: setNoLockScreen,                   // 设置无锁屏
    activateAppDeviceAdmin: activateAppDeviceAdmin,     // 打开指定的设备管理器并激活
    closeNtfOrder: closeNtfOrder,                       // 关闭应用的通知权限

}